"""
API库选项卡
提供完整的API配置管理功能，支持HTTP方法、参数、请求头和请求体等设置
"""
import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext
import requests
import json
import time
import yaml
import os
from typing import Dict, Any, List, Tuple


def create_api_database_tab(tab_control: ttk.Notebook, parent_gui) -> ttk.Frame:
    """
    创建API库选项卡
    :param tab_control: 选项卡控制器
    :param parent_gui: 父窗口GUI实例
    :return: 创建好的选项卡框架
    """
    # 创建选项卡框架
    api_tab = ttk.Frame(tab_control)
    
    # 添加选项卡到控制器
    tab_control.add(api_tab, text="API库")
    
    # 配置选项卡的网格权重，使内容可以撑满整个选项卡
    api_tab.columnconfigure(0, weight=1)
    api_tab.rowconfigure(0, weight=1)
    
    # 创建主框架
    main_frame = ttk.Frame(api_tab, padding="10")
    main_frame.grid(row=0, column=0, sticky="ewns")
    
    # 配置主框架的网格权重
    main_frame.columnconfigure(0, weight=1)
    main_frame.columnconfigure(1, weight=3)
    main_frame.rowconfigure(0, weight=0)  # 标题行
    main_frame.rowconfigure(1, weight=0)  # 工具栏行
    main_frame.rowconfigure(2, weight=1)  # 主内容区
    
    # 标题
    ttk.Label(main_frame, text="API库管理", font=('Arial', 14, 'bold')).grid(
        row=0, column=0, columnspan=2, pady=(5, 5), sticky="w")
    
    # 创建工具栏区域
    toolbar_frame = ttk.Frame(main_frame)
    toolbar_frame.grid(row=1, column=0, columnspan=2, pady=(0, 5), sticky="ew")
    toolbar_frame.columnconfigure(0, weight=1)
    
    # 创建工具栏按钮
    ttk.Button(toolbar_frame, text="添加API", command=lambda: add_api_config(parent_gui)).pack(side="left", padx=3, pady=3)
    ttk.Button(toolbar_frame, text="保存API配置", command=lambda: save_current_api_config(parent_gui)).pack(side="left", padx=3, pady=3)
    ttk.Button(toolbar_frame, text="测试API", command=lambda: test_api_config(parent_gui)).pack(side="left", padx=3, pady=3)
    ttk.Button(toolbar_frame, text="删除选中", command=lambda: delete_selected_api(parent_gui)).pack(side="left", padx=3, pady=3)
    ttk.Button(toolbar_frame, text="加载API列表", command=lambda: load_api_list_from_config(parent_gui)).pack(side="left", padx=3, pady=3)
    ttk.Button(toolbar_frame, text="导出API列表", command=lambda: export_api_list(parent_gui)).pack(side="left", padx=3, pady=3)
    ttk.Button(toolbar_frame, text="导入API列表", command=lambda: import_api_list(parent_gui)).pack(side="left", padx=3, pady=3)
    ttk.Button(toolbar_frame, text="清空表单", command=lambda: clear_api_form(parent_gui)).pack(side="left", padx=3, pady=3)
    
    # API配置列表区域
    list_frame = ttk.LabelFrame(main_frame, text="API配置列表", padding="5")
    list_frame.grid(row=2, column=0, sticky="nsew", pady=(0, 5))
    list_frame.columnconfigure(0, weight=1)
    list_frame.rowconfigure(0, weight=1)
    
    # 创建列表视图 - 减小高度
    columns = ("name", "url", "method", "auth_type")
    parent_gui.api_listview = ttk.Treeview(list_frame, columns=columns, show="headings", height=8)
    
    # 定义列
    parent_gui.api_listview.heading("name", text="API名称")
    parent_gui.api_listview.heading("url", text="基础URL")
    parent_gui.api_listview.heading("method", text="方法")
    parent_gui.api_listview.heading("auth_type", text="认证")
    
    # 设置列宽和对齐方式
    parent_gui.api_listview.column("name", width=80, anchor="w")
    parent_gui.api_listview.column("url", width=150, anchor="w")
    parent_gui.api_listview.column("method", width=50, anchor="center")
    parent_gui.api_listview.column("auth_type", width=50, anchor="center")
    
    # 添加滚动条
    list_scrollbar = ttk.Scrollbar(list_frame, orient="vertical", command=parent_gui.api_listview.yview)
    parent_gui.api_listview.configure(yscroll=list_scrollbar.set)
    
    # 放置列表和滚动条
    parent_gui.api_listview.grid(row=0, column=0, sticky="nsew")
    list_scrollbar.grid(row=0, column=1, sticky="ns")
    
    # 绑定双击事件，用于编辑选中的API配置
    parent_gui.api_listview.bind("<Double-1>", lambda event: on_edit_api(parent_gui))
    
    # API配置区域 - 使用更紧凑的布局
    config_frame = ttk.LabelFrame(main_frame, text="API配置详情", padding="5")
    config_frame.grid(row=2, column=1, sticky="nsew", pady=(0, 5), padx=(10, 0))
    config_frame.columnconfigure(1, weight=1)
    config_frame.columnconfigure(3, weight=1)
    
    # 基本信息区域 - 使用两列布局减少垂直空间占用
    # API名称配置
    ttk.Label(config_frame, text="API名称:").grid(row=0, column=0, sticky="w", pady=2, padx=(0, 5))
    parent_gui.api_name_var = tk.StringVar()
    ttk.Entry(config_frame, textvariable=parent_gui.api_name_var).grid(row=0, column=1, sticky="ew", pady=2)
    
    # HTTP方法配置
    ttk.Label(config_frame, text="HTTP方法:").grid(row=0, column=2, sticky="w", pady=2, padx=(10, 5))
    parent_gui.api_method_var = tk.StringVar(value="GET")
    method_combo = ttk.Combobox(config_frame, textvariable=parent_gui.api_method_var, 
                               values=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
                               state="readonly", width=8)
    method_combo.grid(row=0, column=3, sticky="w", pady=2)
    
    # API基础URL配置
    ttk.Label(config_frame, text="基础URL:").grid(row=1, column=0, sticky="w", pady=2, padx=(0, 5))
    parent_gui.api_base_url_var = tk.StringVar()
    ttk.Entry(config_frame, textvariable=parent_gui.api_base_url_var).grid(row=1, column=1, columnspan=3, sticky="ew", pady=2)
    
    # 路径配置
    ttk.Label(config_frame, text="请求路径:").grid(row=2, column=0, sticky="w", pady=2, padx=(0, 5))
    parent_gui.api_path_var = tk.StringVar(value="/")
    ttk.Entry(config_frame, textvariable=parent_gui.api_path_var).grid(row=2, column=1, columnspan=3, sticky="ew", pady=2)
    
    # API认证方式配置
    ttk.Label(config_frame, text="认证方式:").grid(row=3, column=0, sticky="w", pady=2, padx=(0, 5))
    parent_gui.api_auth_type_var = tk.StringVar(value="API Key")
    auth_type_combo = ttk.Combobox(config_frame, textvariable=parent_gui.api_auth_type_var, 
                                 values=["API Key", "OAuth2", "None"],
                                 state="readonly", width=10)
    auth_type_combo.grid(row=3, column=1, sticky="w", pady=2)
    auth_type_combo.bind("<<ComboboxSelected>>", lambda event: on_auth_type_change(parent_gui, config_frame))
    
    # API Key配置
    parent_gui.api_key_var = tk.StringVar()
    parent_gui.api_key_header_var = tk.StringVar(value="Authorization")
    parent_gui.api_key_frame = ttk.Frame(config_frame)
    ttk.Label(parent_gui.api_key_frame, text="API Key:").grid(row=0, column=0, sticky="w", padx=(0, 5), pady=2)
    ttk.Entry(parent_gui.api_key_frame, textvariable=parent_gui.api_key_var, show="*").grid(row=0, column=1, sticky="ew", pady=2)
    ttk.Label(parent_gui.api_key_frame, text="请求头:").grid(row=0, column=2, sticky="w", padx=(10, 5), pady=2)
    ttk.Entry(parent_gui.api_key_frame, textvariable=parent_gui.api_key_header_var, width=15).grid(row=0, column=3, sticky="w", pady=2)
    
    # OAuth2配置
    parent_gui.oauth_frame = ttk.Frame(config_frame)
    ttk.Label(parent_gui.oauth_frame, text="Client ID:").grid(row=0, column=0, sticky="w", padx=(0, 5), pady=2)
    parent_gui.oauth_client_id_var = tk.StringVar()
    ttk.Entry(parent_gui.oauth_frame, textvariable=parent_gui.oauth_client_id_var).grid(row=0, column=1, sticky="ew", pady=2)
    
    ttk.Label(parent_gui.oauth_frame, text="Client Secret:").grid(row=1, column=0, sticky="w", padx=(0, 5), pady=2)
    parent_gui.oauth_client_secret_var = tk.StringVar()
    ttk.Entry(parent_gui.oauth_frame, textvariable=parent_gui.oauth_client_secret_var, show="*").grid(row=1, column=1, sticky="ew", pady=2)
    
    ttk.Label(parent_gui.oauth_frame, text="Token URL:").grid(row=2, column=0, sticky="w", padx=(0, 5), pady=2)
    parent_gui.oauth_token_url_var = tk.StringVar()
    ttk.Entry(parent_gui.oauth_frame, textvariable=parent_gui.oauth_token_url_var).grid(row=2, column=1, columnspan=3, sticky="ew", pady=2)
    
    # 参数设置区域 - 减小padding和间距
    params_frame = ttk.LabelFrame(config_frame, text="URL参数设置", padding="5")
    params_frame.grid(row=5, column=0, columnspan=4, sticky="ewns", pady=(5, 0))
    params_frame.columnconfigure(0, weight=1)
    params_frame.columnconfigure(1, weight=3)
    params_frame.rowconfigure(0, weight=1)
    
    # 参数名称和值
    ttk.Label(params_frame, text="参数名:").grid(row=0, column=0, sticky="w", pady=2, padx=(0, 5))
    parent_gui.param_name_var = tk.StringVar()
    ttk.Entry(params_frame, textvariable=parent_gui.param_name_var).grid(row=0, column=1, sticky="ew", pady=2)
    
    ttk.Label(params_frame, text="参数值:").grid(row=0, column=2, sticky="w", pady=2, padx=(10, 5))
    parent_gui.param_value_var = tk.StringVar()
    ttk.Entry(params_frame, textvariable=parent_gui.param_value_var).grid(row=0, column=3, sticky="ew", pady=2)
    
    # 参数列表 - 减小高度
    parent_gui.params_listbox = tk.Listbox(params_frame, width=40, height=2)
    parent_gui.params_listbox.grid(row=1, column=0, columnspan=3, sticky="ewns", pady=3)
    
    # 参数操作按钮
    params_button_frame = ttk.Frame(params_frame)
    params_button_frame.grid(row=1, column=3, sticky="n", pady=3)
    ttk.Button(params_button_frame, text="添加", command=lambda: add_param(parent_gui)).pack(fill="x", pady=1)
    ttk.Button(params_button_frame, text="删除", command=lambda: remove_param(parent_gui)).pack(fill="x", pady=1)
    
    # 请求头设置区域 - 减小padding和间距
    headers_frame = ttk.LabelFrame(config_frame, text="请求头设置", padding="5")
    headers_frame.grid(row=6, column=0, columnspan=4, sticky="ewns", pady=(5, 0))
    headers_frame.columnconfigure(0, weight=1)
    headers_frame.columnconfigure(1, weight=3)
    headers_frame.rowconfigure(0, weight=1)
    
    # 请求头名称和值
    ttk.Label(headers_frame, text="头部名:").grid(row=0, column=0, sticky="w", pady=2, padx=(0, 5))
    parent_gui.header_name_var = tk.StringVar()
    ttk.Entry(headers_frame, textvariable=parent_gui.header_name_var).grid(row=0, column=1, sticky="ew", pady=2)
    
    ttk.Label(headers_frame, text="头部值:").grid(row=0, column=2, sticky="w", pady=2, padx=(10, 5))
    parent_gui.header_value_var = tk.StringVar()
    ttk.Entry(headers_frame, textvariable=parent_gui.header_value_var).grid(row=0, column=3, sticky="ew", pady=2)
    
    # 请求头列表 - 减小高度
    parent_gui.headers_listbox = tk.Listbox(headers_frame, width=40, height=2)
    parent_gui.headers_listbox.grid(row=1, column=0, columnspan=3, sticky="ewns", pady=3)
    
    # 请求头操作按钮
    headers_button_frame = ttk.Frame(headers_frame)
    headers_button_frame.grid(row=1, column=3, sticky="n", pady=3)
    ttk.Button(headers_button_frame, text="添加", command=lambda: add_header(parent_gui)).pack(fill="x", pady=1)
    ttk.Button(headers_button_frame, text="删除", command=lambda: remove_header(parent_gui)).pack(fill="x", pady=1)
    
    # 请求体设置区域 - 减小padding和间距
    body_frame = ttk.LabelFrame(config_frame, text="请求体设置", padding="5")
    body_frame.grid(row=7, column=0, columnspan=4, sticky="ewns", pady=(5, 0))
    body_frame.columnconfigure(0, weight=1)
    body_frame.rowconfigure(1, weight=1)
    
    # 内容类型选择
    ttk.Label(body_frame, text="内容类型:").grid(row=0, column=0, sticky="w", pady=2, padx=(0, 5))
    parent_gui.content_type_var = tk.StringVar(value="application/json")
    content_type_combo = ttk.Combobox(body_frame, textvariable=parent_gui.content_type_var, 
                                     values=["application/json", "application/x-www-form-urlencoded", "text/plain"],
                                     state="readonly")
    content_type_combo.grid(row=0, column=1, sticky="w", pady=2)
    
    # 请求体文本区域 - 减小高度
    parent_gui.request_body_text = scrolledtext.ScrolledText(body_frame, height=3, width=50)
    parent_gui.request_body_text.grid(row=1, column=0, columnspan=4, sticky="ewns", pady=3)
    
    
    # 初始化API列表和表单状态
    load_api_list_from_config(parent_gui)
    on_auth_type_change(parent_gui, config_frame)  # 初始化认证框架显示状态
    
    return api_tab


def on_auth_type_change(parent_gui, config_frame):
    """处理认证方式变更"""
    auth_type = parent_gui.api_auth_type_var.get()
    
    # 隐藏所有认证相关的框架
    if hasattr(parent_gui, 'api_key_frame'):
        parent_gui.api_key_frame.grid_remove()
    if hasattr(parent_gui, 'oauth_frame'):
        parent_gui.oauth_frame.grid_remove()
    
    # 根据选择的认证方式显示对应的配置框架
    if auth_type == "API Key" and hasattr(parent_gui, 'api_key_frame'):
        parent_gui.api_key_frame.grid(row=4, column=0, columnspan=4, sticky="ew", pady=2)
    elif auth_type == "OAuth2" and hasattr(parent_gui, 'oauth_frame'):
        parent_gui.oauth_frame.grid(row=4, column=0, columnspan=4, sticky="ew", pady=2)


def add_param(parent_gui):
    """添加URL参数"""
    try:
        param_name = parent_gui.param_name_var.get().strip()
        param_value = parent_gui.param_value_var.get().strip()
        
        if not param_name:
            messagebox.showwarning("警告", "参数名不能为空", parent=parent_gui.root)
            return
        
        # 检查参数是否已存在
        for i in range(parent_gui.params_listbox.size()):
            existing_param = parent_gui.params_listbox.get(i)
            if existing_param.startswith(f"{param_name}="):
                if not messagebox.askyesno("确认", f"参数 '{param_name}' 已存在，是否覆盖？", parent=parent_gui.root):
                    return
                parent_gui.params_listbox.delete(i)
                break
        
        # 添加参数到列表
        parent_gui.params_listbox.insert("end", f"{param_name}={param_value}")
        
        # 清空输入框
        parent_gui.param_name_var.set("")
        parent_gui.param_value_var.set("")
    except Exception as e:
        messagebox.showerror("错误", f"添加参数失败: {str(e)}", parent=parent_gui.root)


def remove_param(parent_gui):
    """删除选中的URL参数"""
    try:
        selected_indices = parent_gui.params_listbox.curselection()
        if not selected_indices:
            messagebox.showwarning("警告", "请先选择要删除的参数", parent=parent_gui.root)
            return
        
        # 从后往前删除，避免索引变化问题
        for i in sorted(selected_indices, reverse=True):
            parent_gui.params_listbox.delete(i)
    except Exception as e:
        messagebox.showerror("错误", f"删除参数失败: {str(e)}", parent=parent_gui.root)


def add_header(parent_gui):
    """添加请求头"""
    try:
        header_name = parent_gui.header_name_var.get().strip()
        header_value = parent_gui.header_value_var.get().strip()
        
        if not header_name:
            messagebox.showwarning("警告", "头部名不能为空", parent=parent_gui.root)
            return
        
        # 检查请求头是否已存在
        for i in range(parent_gui.headers_listbox.size()):
            existing_header = parent_gui.headers_listbox.get(i)
            if existing_header.startswith(f"{header_name}:"):
                if not messagebox.askyesno("确认", f"请求头 '{header_name}' 已存在，是否覆盖？", parent=parent_gui.root):
                    return
                parent_gui.headers_listbox.delete(i)
                break
        
        # 添加请求头到列表
        parent_gui.headers_listbox.insert("end", f"{header_name}: {header_value}")
        
        # 清空输入框
        parent_gui.header_name_var.set("")
        parent_gui.header_value_var.set("")
    except Exception as e:
        messagebox.showerror("错误", f"添加请求头失败: {str(e)}", parent=parent_gui.root)


def remove_header(parent_gui):
    """删除选中的请求头"""
    try:
        selected_indices = parent_gui.headers_listbox.curselection()
        if not selected_indices:
            messagebox.showwarning("警告", "请先选择要删除的请求头", parent=parent_gui.root)
            return
        
        # 从后往前删除，避免索引变化问题
        for i in sorted(selected_indices, reverse=True):
            parent_gui.headers_listbox.delete(i)
    except Exception as e:
        messagebox.showerror("错误", f"删除请求头失败: {str(e)}", parent=parent_gui.root)

def test_api_config(parent_gui):
    """测试API配置"""
    try:
        # 收集配置信息
        api_name = parent_gui.api_name_var.get().strip()
        if not api_name:
            messagebox.showwarning("警告", "请先选择或填写API配置", parent=parent_gui.root)
            return
        
        base_url = parent_gui.api_base_url_var.get().strip()
        if not base_url:
            messagebox.showwarning("警告", "基础URL不能为空", parent=parent_gui.root)
            return
        
        path = parent_gui.api_path_var.get().strip()
        if not path.startswith('/'):
            path = '/' + path
        
        url = base_url.rstrip('/') + path
        method = parent_gui.api_method_var.get()
        auth_type = parent_gui.api_auth_type_var.get()
        content_type = parent_gui.content_type_var.get()
        
        # 收集URL参数
        params = {}
        for i in range(parent_gui.params_listbox.size()):
            param_str = parent_gui.params_listbox.get(i)
            if '=' in param_str:
                name, value = param_str.split('=', 1)
                params[name] = value
        
        # 收集请求头
        headers = {
            'Content-Type': content_type
        }
        for i in range(parent_gui.headers_listbox.size()):
            header_str = parent_gui.headers_listbox.get(i)
            if ':' in header_str:
                name, value = header_str.split(':', 1)
                headers[name.strip()] = value.strip()
        
        # 根据认证类型添加认证信息
        if auth_type == "API Key" and hasattr(parent_gui, 'api_key_var'):
            api_key = parent_gui.api_key_var.get()
            api_key_header = parent_gui.api_key_header_var.get()
            if api_key and api_key_header:
                headers[api_key_header] = api_key
        
        # 获取请求体
        request_body = parent_gui.request_body_text.get("1.0", tk.END).strip()
        
        # 显示测试开始提示
        messagebox.showinfo("测试开始", f"正在测试API: {api_name}\n请求URL: {url}", parent=parent_gui.root)
        
        # 发送请求并记录时间
        start_time = time.time()
        
        try:
            if method == "GET":
                response = requests.get(url, params=params, headers=headers, timeout=30)
            elif method == "POST":
                if content_type == "application/json" and request_body:
                    data = json.loads(request_body)
                else:
                    data = request_body
                response = requests.post(url, params=params, headers=headers, data=data, timeout=30)
            elif method == "PUT":
                if content_type == "application/json" and request_body:
                    data = json.loads(request_body)
                else:
                    data = request_body
                response = requests.put(url, params=params, headers=headers, data=data, timeout=30)
            elif method == "DELETE":
                response = requests.delete(url, params=params, headers=headers, timeout=30)
            else:
                messagebox.showerror("错误", f"不支持的HTTP方法: {method}", parent=parent_gui.root)
                return
            
            end_time = time.time()
            response_time = round(end_time - start_time, 3)
            
            # 显示响应结果
            show_response_dialog(parent_gui, api_name, url, method, response, response_time)
            
        except requests.exceptions.RequestException as e:
            messagebox.showerror("请求失败", f"API请求失败: {str(e)}", parent=parent_gui.root)
            return
    except Exception as e:
        messagebox.showerror("错误", f"测试API失败: {str(e)}", parent=parent_gui.root)

def show_response_dialog(parent_gui, api_name, url, method, response, response_time):
    """显示API响应结果对话框"""
    # 创建响应对话框
    response_window = tk.Toplevel(parent_gui.root)
    response_window.title(f"API响应 - {api_name}")
    response_window.geometry("800x600")
    response_window.transient(parent_gui.root)
    response_window.grab_set()
    
    # 配置窗口网格
    response_window.columnconfigure(0, weight=1)
    response_window.rowconfigure(0, weight=0)
    response_window.rowconfigure(1, weight=1)
    
    # 显示请求信息
    info_frame = ttk.LabelFrame(response_window, text="请求信息")
    info_frame.grid(row=0, column=0, padx=10, pady=5, sticky="ew")
    
    ttk.Label(info_frame, text=f"API名称: {api_name}").grid(row=0, column=0, sticky="w", padx=5, pady=2)
    ttk.Label(info_frame, text=f"URL: {url}").grid(row=1, column=0, sticky="w", padx=5, pady=2)
    ttk.Label(info_frame, text=f"方法: {method}").grid(row=0, column=1, sticky="w", padx=5, pady=2)
    ttk.Label(info_frame, text=f"响应时间: {response_time}秒").grid(row=1, column=1, sticky="w", padx=5, pady=2)
    ttk.Label(info_frame, text=f"状态码: {response.status_code} ({response.reason})").grid(row=0, column=2, sticky="w", padx=5, pady=2)
    
    # 显示响应头
    headers_frame = ttk.LabelFrame(response_window, text="响应头")
    headers_frame.grid(row=1, column=0, padx=10, pady=(0, 5), sticky="ew")
    headers_frame.columnconfigure(0, weight=1)
    
    headers_text = scrolledtext.ScrolledText(headers_frame, height=5, wrap=tk.WORD)
    headers_text.grid(row=0, column=0, sticky="ewns", padx=5, pady=5)
    headers_text.config(state=tk.DISABLED)
    
    # 添加响应头到文本框
    headers_content = "\n".join([f"{key}: {value}" for key, value in response.headers.items()])
    headers_text.config(state=tk.NORMAL)
    headers_text.insert(tk.END, headers_content)
    headers_text.config(state=tk.DISABLED)
    
    # 显示响应体
    body_frame = ttk.LabelFrame(response_window, text="响应体")
    body_frame.grid(row=2, column=0, padx=10, pady=5, sticky="ewns")
    body_frame.columnconfigure(0, weight=1)
    body_frame.rowconfigure(0, weight=1)
    
    body_text = scrolledtext.ScrolledText(body_frame, height=15, wrap=tk.WORD)
    body_text.grid(row=0, column=0, sticky="ewns", padx=5, pady=5)
    body_text.config(state=tk.DISABLED)
    
    # 格式化响应体（如果是JSON）
    try:
        body_content = response.json()
        formatted_body = json.dumps(body_content, ensure_ascii=False, indent=2)
    except ValueError:
        formatted_body = response.text
    
    # 添加响应体到文本框
    body_text.config(state=tk.NORMAL)
    body_text.insert(tk.END, formatted_body)
    body_text.config(state=tk.DISABLED)
    
    # 添加关闭按钮
    button_frame = ttk.Frame(response_window)
    button_frame.grid(row=3, column=0, padx=10, pady=10)
    
    ttk.Button(button_frame, text="关闭", command=response_window.destroy).pack(pady=5)


def add_api_config(parent_gui):
    """添加新的API配置"""
    try:
        api_name = parent_gui.api_name_var.get().strip()
        if not api_name:
            messagebox.showerror("错误", "API名称不能为空", parent=parent_gui.root)
            return
        
        # 检查API名称是否已存在
        if hasattr(parent_gui, 'api_config_manager'):
            parent_gui.api_config_manager.load_config()
            api_configs = parent_gui.api_config_manager.config.get("apis", {})
            if api_name in api_configs:
                if not messagebox.askyesno("确认", f"API名称 '{api_name}' 已存在，是否覆盖？", parent=parent_gui.root):
                    return
        
        # 保存API配置
        save_current_api_config(parent_gui)
        
    except Exception as e:
        messagebox.showerror("错误", f"添加API配置失败: {str(e)}", parent=parent_gui.root)


def save_current_api_config(parent_gui):
    """保存当前表单中的API配置"""
    try:
        api_name = parent_gui.api_name_var.get().strip()
        if not api_name:
            messagebox.showerror("错误", "API名称不能为空", parent=parent_gui.root)
            return
        
        # 收集配置信息
        config = {
            "base_url": parent_gui.api_base_url_var.get(),
            "path": parent_gui.api_path_var.get(),
            "method": parent_gui.api_method_var.get(),
            "auth_type": parent_gui.api_auth_type_var.get(),
            "content_type": parent_gui.content_type_var.get(),
            "request_body": parent_gui.request_body_text.get("1.0", tk.END).strip()
        }
        
        # 收集URL参数
        params = {}
        for i in range(parent_gui.params_listbox.size()):
            param_str = parent_gui.params_listbox.get(i)
            if '=' in param_str:
                name, value = param_str.split('=', 1)
                params[name] = value
        config["params"] = params
        
        # 收集请求头
        headers = {}
        for i in range(parent_gui.headers_listbox.size()):
            header_str = parent_gui.headers_listbox.get(i)
            if ':' in header_str:
                name, value = header_str.split(':', 1)
                headers[name.strip()] = value.strip()
        config["headers"] = headers
        
        # 根据认证类型收集认证信息
        if config["auth_type"] == "API Key" and hasattr(parent_gui, 'api_key_var'):
            config["api_key"] = parent_gui.api_key_var.get()
            config["api_key_header"] = parent_gui.api_key_header_var.get()
        elif config["auth_type"] == "OAuth2":
            if hasattr(parent_gui, 'oauth_client_id_var'):
                config["oauth_client_id"] = parent_gui.oauth_client_id_var.get()
            if hasattr(parent_gui, 'oauth_client_secret_var'):
                config["oauth_client_secret"] = parent_gui.oauth_client_secret_var.get()
            if hasattr(parent_gui, 'oauth_token_url_var'):
                config["oauth_token_url"] = parent_gui.oauth_token_url_var.get()
        
        # 保存到配置文件
        if hasattr(parent_gui, 'api_config_manager'):
            parent_gui.api_config_manager.load_config()
            # 确保apis配置项存在
            if "apis" not in parent_gui.api_config_manager.config:
                parent_gui.api_config_manager.config["apis"] = {}
            # 保存当前API配置
            parent_gui.api_config_manager.config["apis"][api_name] = config
            parent_gui.api_config_manager.save_config()
            
            # 更新列表显示
            update_api_list(parent_gui)
            messagebox.showinfo("成功", "API配置已保存", parent=parent_gui.root)
        else:
            messagebox.showerror("错误", "配置管理器未初始化", parent=parent_gui.root)
    except Exception as e:
        messagebox.showerror("错误", f"保存配置失败: {str(e)}", parent=parent_gui.root)


def delete_selected_api(parent_gui):
    """删除选中的API配置"""
    try:
        selected_items = parent_gui.api_listview.selection()
        if not selected_items:
            messagebox.showwarning("警告", "请先选择要删除的API配置", parent=parent_gui.root)
            return
        
        # 获取选中项的API名称
        item = selected_items[0]
        api_name = parent_gui.api_listview.item(item, "values")[0]
        
        # 确认删除
        if not messagebox.askyesno("确认删除", f"确定要删除API配置 '{api_name}' 吗？", parent=parent_gui.root):
            return
        
        # 从配置文件中删除
        if hasattr(parent_gui, 'api_config_manager'):
            parent_gui.api_config_manager.load_config()
            if "apis" in parent_gui.api_config_manager.config and api_name in parent_gui.api_config_manager.config["apis"]:
                del parent_gui.api_config_manager.config["apis"][api_name]
                parent_gui.api_config_manager.save_config()
                
                # 更新列表显示
                update_api_list(parent_gui)
                messagebox.showinfo("成功", f"API配置 '{api_name}' 已删除", parent=parent_gui.root)
    except Exception as e:
        messagebox.showerror("错误", f"删除API配置失败: {str(e)}", parent=parent_gui.root)


def on_edit_api(parent_gui):
    """编辑选中的API配置"""
    try:
        selected_items = parent_gui.api_listview.selection()
        if not selected_items:
            return
        
        # 获取选中项的API名称
        item = selected_items[0]
        api_name = parent_gui.api_listview.item(item, "values")[0]
        
        # 加载API配置到表单
        if hasattr(parent_gui, 'api_config_manager'):
            parent_gui.api_config_manager.load_config()
            api_configs = parent_gui.api_config_manager.config.get("apis", {})
            if api_name in api_configs:
                config = api_configs[api_name]
                
                # 加载基本信息
                parent_gui.api_name_var.set(api_name)
                parent_gui.api_base_url_var.set(config.get("base_url", ""))
                parent_gui.api_path_var.set(config.get("path", "/"))
                parent_gui.api_method_var.set(config.get("method", "GET"))
                parent_gui.api_auth_type_var.set(config.get("auth_type", "API Key"))
                parent_gui.content_type_var.set(config.get("content_type", "application/json"))
                parent_gui.request_body_text.delete("1.0", tk.END)
                parent_gui.request_body_text.insert(tk.END, config.get("request_body", ""))
                
                # 清空并加载URL参数
                parent_gui.params_listbox.delete(0, tk.END)
                params = config.get("params", {})
                for name, value in params.items():
                    parent_gui.params_listbox.insert(tk.END, f"{name}={value}")
                
                # 清空并加载请求头
                parent_gui.headers_listbox.delete(0, tk.END)
                headers = config.get("headers", {})
                for name, value in headers.items():
                    parent_gui.headers_listbox.insert(tk.END, f"{name}: {value}")
                
                # 根据认证类型显示对应的配置
                auth_type = config.get("auth_type", "API Key")
                if auth_type == "API Key" and hasattr(parent_gui, 'api_key_var'):
                    parent_gui.api_key_var.set(config.get("api_key", ""))
                    parent_gui.api_key_header_var.set(config.get("api_key_header", "Authorization"))
                    parent_gui.api_key_frame.grid(row=4, column=0, columnspan=4, sticky="ew", pady=4)
                elif auth_type == "OAuth2":
                    if hasattr(parent_gui, 'oauth_client_id_var'):
                        parent_gui.oauth_client_id_var.set(config.get("oauth_client_id", ""))
                    if hasattr(parent_gui, 'oauth_client_secret_var'):
                        parent_gui.oauth_client_secret_var.set(config.get("oauth_client_secret", ""))
                    if hasattr(parent_gui, 'oauth_token_url_var'):
                        parent_gui.oauth_token_url_var.set(config.get("oauth_token_url", ""))
                    parent_gui.oauth_frame.grid(row=4, column=0, columnspan=4, sticky="ew", pady=4)
    except Exception as e:
        messagebox.showerror("错误", f"加载API配置失败: {str(e)}", parent=parent_gui.root)


def update_api_list(parent_gui):
    """更新API列表显示"""
    # 清空当前列表
    for item in parent_gui.api_listview.get_children():
        parent_gui.api_listview.delete(item)
    
    # 重新加载配置并显示
    load_api_list_from_config(parent_gui)


def clear_api_form(parent_gui):
    """清空API配置表单"""
    # 清空基本信息
    parent_gui.api_name_var.set("")
    parent_gui.api_base_url_var.set("")
    parent_gui.api_path_var.set("/")
    parent_gui.api_method_var.set("GET")
    parent_gui.api_auth_type_var.set("API Key")
    parent_gui.content_type_var.set("application/json")
    parent_gui.request_body_text.delete("1.0", tk.END)
    
    # 清空认证信息
    parent_gui.api_key_var.set("")
    parent_gui.api_key_header_var.set("Authorization")
    if hasattr(parent_gui, 'oauth_client_id_var'):
        parent_gui.oauth_client_id_var.set("")
    if hasattr(parent_gui, 'oauth_client_secret_var'):
        parent_gui.oauth_client_secret_var.set("")
    if hasattr(parent_gui, 'oauth_token_url_var'):
        parent_gui.oauth_token_url_var.set("")
    
    # 清空参数和请求头
    parent_gui.params_listbox.delete(0, tk.END)
    parent_gui.headers_listbox.delete(0, tk.END)
    parent_gui.param_name_var.set("")
    parent_gui.param_value_var.set("")
    parent_gui.header_name_var.set("")
    parent_gui.header_value_var.set("")
    
    # 隐藏认证框架
    if hasattr(parent_gui, 'api_key_frame'):
        parent_gui.api_key_frame.grid_remove()
    if hasattr(parent_gui, 'oauth_frame'):
        parent_gui.oauth_frame.grid_remove()
    
    # 显示API Key框架（默认）
    if hasattr(parent_gui, 'api_key_frame'):
        parent_gui.api_key_frame.grid(row=4, column=0, columnspan=4, sticky="ew", pady=4)


def load_api_list_from_config(parent_gui):
    """从配置文件加载API列表"""
    try:
        if hasattr(parent_gui, 'api_config_manager') and hasattr(parent_gui, 'api_listview'):
            parent_gui.api_config_manager.load_config()
            
            # 清空当前列表
            for item in parent_gui.api_listview.get_children():
                parent_gui.api_listview.delete(item)
            
            # 加载所有API配置到列表
            api_configs = parent_gui.api_config_manager.config.get("apis", {})
            for api_name, config in api_configs.items():
                parent_gui.api_listview.insert("", "end", values=(
                    api_name, 
                    config.get("base_url", ""),
                    config.get("method", "GET"),
                    config.get("auth_type", "None")
                ))
    except Exception as e:
        # 静默处理错误，避免在初始化时弹出错误消息
        pass

def export_api_list(parent_gui):
    """导出API配置列表"""
    try:
        if hasattr(parent_gui, 'api_config_manager'):
            parent_gui.api_config_manager.load_config()
            api_configs = parent_gui.api_config_manager.config.get("apis", {})
            
            if not api_configs:
                messagebox.showinfo("提示", "没有可导出的API配置", parent=parent_gui.root)
                return
            
            # 让用户选择保存路径
            file_path = tk.filedialog.asksaveasfilename(
                defaultextension=".yaml",
                filetypes=[("YAML文件", "*.yaml"), ("所有文件", "*.*")],
                title="导出API配置列表",
                parent=parent_gui.root
            )
            
            if file_path:
                # 创建只包含apis部分的配置数据
                export_data = {"apis": api_configs}
                
                # 保存到文件
                with open(file_path, 'w', encoding='utf-8') as f:
                    yaml.dump(export_data, f, allow_unicode=True, default_flow_style=False)
                
                messagebox.showinfo("成功", f"API配置列表已成功导出到:\n{file_path}", parent=parent_gui.root)
    except Exception as e:
        messagebox.showerror("错误", f"导出API配置列表失败: {str(e)}", parent=parent_gui.root)

def import_api_list(parent_gui):
    """导入API配置列表"""
    try:
        if hasattr(parent_gui, 'api_config_manager'):
            # 让用户选择要导入的文件
            file_path = tk.filedialog.askopenfilename(
                filetypes=[("YAML文件", "*.yaml"), ("所有文件", "*.*")],
                title="导入API配置列表",
                parent=parent_gui.root
            )
            
            if file_path:
                # 加载文件内容
                with open(file_path, 'r', encoding='utf-8') as f:
                    import_data = yaml.safe_load(f)
                
                # 检查文件格式是否正确
                if not isinstance(import_data, dict) or "apis" not in import_data:
                    messagebox.showerror("错误", "导入的文件格式不正确，缺少apis配置", parent=parent_gui.root)
                    return
                
                # 加载现有配置
                parent_gui.api_config_manager.load_config()
                
                # 询问是否覆盖现有配置或合并
                result = messagebox.askyesnocancel(
                    "导入选项",
                    "是否覆盖现有所有API配置？\n\n选择'是'将覆盖所有现有配置\n选择'否'将合并导入的配置（同名的会被覆盖）\n选择'取消'将取消导入",
                    parent=parent_gui.root
                )
                
                if result is None:  # 用户取消
                    return
                
                if result:  # 覆盖现有配置
                    parent_gui.api_config_manager.config["apis"] = import_data["apis"]
                else:  # 合并配置
                    if "apis" not in parent_gui.api_config_manager.config:
                        parent_gui.api_config_manager.config["apis"] = {}
                    parent_gui.api_config_manager.config["apis"].update(import_data["apis"])
                
                # 保存更新后的配置
                parent_gui.api_config_manager.save_config()
                
                # 更新UI列表
                load_api_list_from_config(parent_gui)
                
                messagebox.showinfo("成功", f"API配置列表已成功从以下文件导入:\n{file_path}", parent=parent_gui.root)
    except Exception as e:
        messagebox.showerror("错误", f"导入API配置列表失败: {str(e)}", parent=parent_gui.root)